home *** CD-ROM | disk | FTP | other *** search
/ Openstep 4.2 (Developer) / Openstep Developer 4.2.iso / NextDeveloper / Source / GNU / debug / gdb / readline / isearch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-28  |  9.1 KB  |  381 lines
  1. /* **************************************************************** */
  2. /*                                    */
  3. /*            I-Search and Searching                */
  4. /*                                    */
  5. /* **************************************************************** */
  6.  
  7. /* Copyright (C) 1987,1989 Free Software Foundation, Inc.
  8.  
  9.    This file contains the Readline Library (the Library), a set of
  10.    routines for providing Emacs style line input to programs that ask
  11.    for it.
  12.  
  13.    The Library is free software; you can redistribute it and/or modify
  14.    it under the terms of the GNU General Public License as published by
  15.    the Free Software Foundation; either version 1, or (at your option)
  16.    any later version.
  17.  
  18.    The Library is distributed in the hope that it will be useful, but
  19.    WITHOUT ANY WARRANTY; without even the implied warranty of
  20.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.    General Public License for more details.
  22.  
  23.    The GNU General Public License is often shipped with GNU software, and
  24.    is generally kept in a file called COPYING or LICENSE.  If you do not
  25.    have a copy of the license, write to the Free Software Foundation,
  26.    675 Mass Ave, Cambridge, MA 02139, USA. */
  27.  
  28. /* For alloca on AIX.  CYGNUS LOCAL.  */
  29. #include "sysdep.h"
  30.  
  31. #include <stdio.h>
  32.  
  33. #if defined (__GNUC__)
  34. #  define alloca __builtin_alloca
  35. #else
  36. #  if defined (sparc) || defined (HAVE_ALLOCA_H)
  37. #    include <alloca.h>
  38. #  endif
  39. #endif
  40.  
  41. #include "readline.h"
  42. #include "history.h"
  43.  
  44. extern Keymap _rl_keymap;
  45. extern HIST_ENTRY *saved_line_for_history;
  46. extern int rl_line_buffer_len;
  47. extern int rl_point, rl_end;
  48. extern char *rl_prompt, *rl_line_buffer;
  49.  
  50. /* Remove these declarations when we have a complete libgnu.a. */
  51. extern char *xmalloc (), *xrealloc ();
  52.  
  53. static void rl_search_history ();
  54.  
  55. /* Search backwards through the history looking for a string which is typed
  56.    interactively.  Start with the current line. */
  57. rl_reverse_search_history (sign, key)
  58.      int sign;
  59.      int key;
  60. {
  61.   rl_search_history (-sign, key);
  62. }
  63.  
  64. /* Search forwards through the history looking for a string which is typed
  65.    interactively.  Start with the current line. */
  66. rl_forward_search_history (sign, key)
  67.      int sign;
  68.      int key;
  69. {
  70.   rl_search_history (sign, key);
  71. }
  72.  
  73. /* Display the current state of the search in the echo-area.
  74.    SEARCH_STRING contains the string that is being searched for,
  75.    DIRECTION is zero for forward, or 1 for reverse,
  76.    WHERE is the history list number of the current line.  If it is
  77.    -1, then this line is the starting one. */
  78. static void
  79. rl_display_search (search_string, reverse_p, where)
  80.      char *search_string;
  81.      int reverse_p, where;
  82. {
  83.   char *message = (char *)NULL;
  84.  
  85.   message =
  86.     (char *)xmalloc (1 + (search_string ? strlen (search_string) : 0) + 30);
  87.  
  88.   *message = '\0';
  89.  
  90. #if defined (NOTDEF)
  91.   if (where != -1)
  92.     sprintf (message, "[%d]", where + history_base);
  93. #endif /* NOTDEF */
  94.  
  95.   strcat (message, "(");
  96.  
  97.   if (reverse_p)
  98.     strcat (message, "reverse-");
  99.  
  100.   strcat (message, "i-search)`");
  101.  
  102.   if (search_string)
  103.     strcat (message, search_string);
  104.  
  105.   strcat (message, "': ");
  106.   rl_message ("%s", message, 0);
  107.   free (message);
  108.   rl_redisplay ();
  109. }
  110.  
  111. /* Search through the history looking for an interactively typed string.
  112.    This is analogous to i-search.  We start the search in the current line.
  113.    DIRECTION is which direction to search; >= 0 means forward, < 0 means
  114.    backwards. */
  115. static void
  116. rl_search_history (direction, invoking_key)
  117.      int direction;
  118.      int invoking_key;
  119. {
  120.   /* The string that the user types in to search for. */
  121.   char *search_string;
  122.  
  123.   /* The current length of SEARCH_STRING. */
  124.   int search_string_index;
  125.  
  126.   /* The amount of space that SEARCH_STRING has allocated to it. */
  127.   int search_string_size;
  128.  
  129.   /* The list of lines to search through. */
  130.   char **lines;
  131.  
  132.   /* The length of LINES. */
  133.   int hlen;
  134.  
  135.   /* Where we get LINES from. */
  136.   HIST_ENTRY **hlist = history_list ();
  137.  
  138.   register int i = 0;
  139.   int orig_point = rl_point;
  140.   int orig_line = where_history ();
  141.   int last_found_line = orig_line;
  142.   int c, done = 0;
  143.  
  144.   /* The line currently being searched. */
  145.   char *sline;
  146.  
  147.   /* Offset in that line. */
  148.   int index;
  149.  
  150.   /* Non-zero if we are doing a reverse search. */
  151.   int reverse = (direction < 0);
  152.  
  153.   /* Create an arrary of pointers to the lines that we want to search. */
  154.   maybe_replace_line ();
  155.   if (hlist)
  156.     for (i = 0; hlist[i]; i++);
  157.  
  158.   /* Allocate space for this many lines, +1 for the current input line,
  159.      and remember those lines. */
  160.   lines = (char **)alloca ((1 + (hlen = i)) * sizeof (char *));
  161.   for (i = 0; i < hlen; i++)
  162.     lines[i] = hlist[i]->line;
  163.  
  164.   if (saved_line_for_history)
  165.     lines[i] = saved_line_for_history->line;
  166.   else
  167.     /* So I have to type it in this way instead. */
  168.     {
  169.       char *alloced_line;
  170.  
  171.       /* Keep that MIPS alloca () happy. */
  172.       alloced_line = (char *)alloca (1 + strlen (rl_line_buffer));
  173.       lines[i] = alloced_line;
  174.       strcpy (lines[i], &rl_line_buffer[0]);
  175.     }
  176.  
  177.   hlen++;
  178.  
  179.   /* The line where we start the search. */
  180.   i = orig_line;
  181.  
  182.   /* Initialize search parameters. */
  183.   search_string = (char *)xmalloc (search_string_size = 128);
  184.   *search_string = '\0';
  185.   search_string_index = 0;
  186.  
  187.   /* Normalize DIRECTION into 1 or -1. */
  188.   if (direction >= 0)
  189.     direction = 1;
  190.   else
  191.     direction = -1;
  192.  
  193.   rl_display_search (search_string, reverse, -1);
  194.  
  195.   sline = rl_line_buffer;
  196.   index = rl_point;
  197.  
  198.   while (!done)
  199.     {
  200.       c = rl_read_key ();
  201.  
  202.       /* Hack C to Do What I Mean. */
  203.       {
  204.     Function *f = (Function *)NULL;
  205.  
  206.     if (_rl_keymap[c].type == ISFUNC)
  207.       {
  208.         f = _rl_keymap[c].function;
  209.  
  210.         if (f == rl_reverse_search_history)
  211.           c = reverse ? -1 : -2;
  212.         else if (f == rl_forward_search_history)
  213.           c =  !reverse ? -1 : -2;
  214.       }
  215.       }
  216.  
  217.       switch (c)
  218.     {
  219.     case ESC:
  220.       done = 1;
  221.       continue;
  222.  
  223.       /* case invoking_key: */
  224.     case -1:
  225.       goto search_again;
  226.  
  227.       /* switch directions */
  228.     case -2:
  229.       direction = -direction;
  230.       reverse = (direction < 0);
  231.  
  232.       goto do_search;
  233.  
  234.     case CTRL ('G'):
  235.       strcpy (rl_line_buffer, lines[orig_line]);
  236.       rl_point = orig_point;
  237.       rl_end = strlen (rl_line_buffer);
  238.       rl_clear_message ();
  239.       return;
  240.  
  241.     default:
  242.       if (c < 32 || c > 126)
  243.         {
  244.           rl_execute_next (c);
  245.           done = 1;
  246.           continue;
  247.         }
  248.       else
  249.         {
  250.           if (search_string_index + 2 >= search_string_size)
  251.         search_string = (char *)xrealloc
  252.           (search_string, (search_string_size += 128));
  253.           search_string[search_string_index++] = c;
  254.           search_string[search_string_index] = '\0';
  255.           goto do_search;
  256.  
  257.         search_again:
  258.  
  259.           if (!search_string_index)
  260.         continue;
  261.           else
  262.         {
  263.           if (reverse)
  264.             --index;
  265.           else
  266.             if (index != strlen (sline))
  267.               ++index;
  268.             else
  269.               ding ();
  270.         }
  271.         do_search:
  272.  
  273.           while (1)
  274.         {
  275.           if (reverse)
  276.             {
  277.               while (index >= 0)
  278.             if (strncmp
  279.                 (search_string, sline + index, search_string_index)
  280.                 == 0)
  281.               goto string_found;
  282.             else
  283.               index--;
  284.             }
  285.           else
  286.             {
  287.               register int limit =
  288.             (strlen (sline) - search_string_index) + 1;
  289.  
  290.               while (index < limit)
  291.             {
  292.               if (strncmp (search_string,
  293.                        sline + index,
  294.                        search_string_index) == 0)
  295.                 goto string_found;
  296.               index++;
  297.             }
  298.             }
  299.  
  300.         next_line:
  301.           i += direction;
  302.  
  303.           /* At limit for direction? */
  304.           if ((reverse && i < 0) ||
  305.               (!reverse && i == hlen))
  306.             goto search_failed;
  307.  
  308.           sline = lines[i];
  309.           if (reverse)
  310.             index = strlen (sline);
  311.           else
  312.             index = 0;
  313.  
  314.           /* If the search string is longer than the current
  315.              line, no match. */
  316.           if (search_string_index > (int)strlen (sline))
  317.             goto next_line;
  318.  
  319.           /* Start actually searching. */
  320.           if (reverse)
  321.             index -= search_string_index;
  322.         }
  323.  
  324.         search_failed:
  325.           /* We cannot find the search string.  Ding the bell. */
  326.           ding ();
  327.           i = last_found_line;
  328.           break;
  329.  
  330.         string_found:
  331.           /* We have found the search string.  Just display it.  But don't
  332.          actually move there in the history list until the user accepts
  333.          the location. */
  334.           {
  335.         int line_len;
  336.  
  337.         line_len = strlen (lines[i]);
  338.  
  339.         if (line_len >= rl_line_buffer_len)
  340.           rl_extend_line_buffer (line_len);
  341.  
  342.         strcpy (rl_line_buffer, lines[i]);
  343.         rl_point = index;
  344.         rl_end = line_len;
  345.         last_found_line = i;
  346.         rl_display_search
  347.           (search_string, reverse, (i == orig_line) ? -1 : i);
  348.           }
  349.         }
  350.     }
  351.     }
  352.  
  353.   /* The searching is over.  The user may have found the string that she
  354.      was looking for, or else she may have exited a failing search.  If
  355.      INDEX is -1, then that shows that the string searched for was not
  356.      found.  We use this to determine where to place rl_point. */
  357.   {
  358.     int now = last_found_line;
  359.  
  360.     /* First put back the original state. */
  361.     strcpy (rl_line_buffer, lines[orig_line]);
  362.  
  363.     /* Free the search string. */
  364.     free (search_string);
  365.  
  366.     if (now < orig_line)
  367.       rl_get_previous_history (orig_line - now);
  368.     else
  369.       rl_get_next_history (now - orig_line);
  370.  
  371.     /* If the index of the "matched" string is less than zero, then the
  372.        final search string was never matched, so put point somewhere
  373.        reasonable. */
  374.     if (index < 0)
  375.       index = strlen (rl_line_buffer);
  376.  
  377.     rl_point = index;
  378.     rl_clear_message ();
  379.   }
  380. }
  381.